home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / virtio_config.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  4.7 KB  |  131 lines
  1. #ifndef _LINUX_VIRTIO_CONFIG_H
  2. #define _LINUX_VIRTIO_CONFIG_H
  3. /* This header, excluding the #ifdef __KERNEL__ part, is BSD licensed so
  4.  * anyone can use the definitions to implement compatible drivers/servers. */
  5.  
  6. /* Virtio devices use a standardized configuration space to define their
  7.  * features and pass configuration information, but each implementation can
  8.  * store and access that space differently. */
  9. #include <linux/types.h>
  10.  
  11. /* Status byte for guest to report progress, and synchronize features. */
  12. /* We have seen device and processed generic fields (VIRTIO_CONFIG_F_VIRTIO) */
  13. #define VIRTIO_CONFIG_S_ACKNOWLEDGE    1
  14. /* We have found a driver for the device. */
  15. #define VIRTIO_CONFIG_S_DRIVER        2
  16. /* Driver has used its parts of the config, and is happy */
  17. #define VIRTIO_CONFIG_S_DRIVER_OK    4
  18. /* We've given up on this device. */
  19. #define VIRTIO_CONFIG_S_FAILED        0x80
  20.  
  21. /* Some virtio feature bits (currently bits 28 through 31) are reserved for the
  22.  * transport being used (eg. virtio_ring), the rest are per-device feature
  23.  * bits. */
  24. #define VIRTIO_TRANSPORT_F_START    28
  25. #define VIRTIO_TRANSPORT_F_END        32
  26.  
  27. /* Do we get callbacks when the ring is completely used, even if we've
  28.  * suppressed them? */
  29. #define VIRTIO_F_NOTIFY_ON_EMPTY    24
  30.  
  31. #ifdef __KERNEL__
  32. #include <linux/virtio.h>
  33.  
  34. /**
  35.  * virtio_config_ops - operations for configuring a virtio device
  36.  * @get: read the value of a configuration field
  37.  *    vdev: the virtio_device
  38.  *    offset: the offset of the configuration field
  39.  *    buf: the buffer to write the field value into.
  40.  *    len: the length of the buffer
  41.  * @set: write the value of a configuration field
  42.  *    vdev: the virtio_device
  43.  *    offset: the offset of the configuration field
  44.  *    buf: the buffer to read the field value from.
  45.  *    len: the length of the buffer
  46.  * @get_status: read the status byte
  47.  *    vdev: the virtio_device
  48.  *    Returns the status byte
  49.  * @set_status: write the status byte
  50.  *    vdev: the virtio_device
  51.  *    status: the new status byte
  52.  * @reset: reset the device
  53.  *    vdev: the virtio device
  54.  *    After this, status and feature negotiation must be done again
  55.  * @find_vq: find a virtqueue and instantiate it.
  56.  *    vdev: the virtio_device
  57.  *    index: the 0-based virtqueue number in case there's more than one.
  58.  *    callback: the virqtueue callback
  59.  *    Returns the new virtqueue or ERR_PTR() (eg. -ENOENT).
  60.  * @del_vq: free a virtqueue found by find_vq().
  61.  * @get_features: get the array of feature bits for this device.
  62.  *    vdev: the virtio_device
  63.  *    Returns the first 32 feature bits (all we currently need).
  64.  * @finalize_features: confirm what device features we'll be using.
  65.  *    vdev: the virtio_device
  66.  *    This gives the final feature bits for the device: it can change
  67.  *    the dev->feature bits if it wants.
  68.  */
  69. struct virtio_config_ops
  70. {
  71.     void (*get)(struct virtio_device *vdev, unsigned offset,
  72.             void *buf, unsigned len);
  73.     void (*set)(struct virtio_device *vdev, unsigned offset,
  74.             const void *buf, unsigned len);
  75.     u8 (*get_status)(struct virtio_device *vdev);
  76.     void (*set_status)(struct virtio_device *vdev, u8 status);
  77.     void (*reset)(struct virtio_device *vdev);
  78.     struct virtqueue *(*find_vq)(struct virtio_device *vdev,
  79.                      unsigned index,
  80.                      void (*callback)(struct virtqueue *));
  81.     void (*del_vq)(struct virtqueue *vq);
  82.     u32 (*get_features)(struct virtio_device *vdev);
  83.     void (*finalize_features)(struct virtio_device *vdev);
  84. };
  85.  
  86. /* If driver didn't advertise the feature, it will never appear. */
  87. void virtio_check_driver_offered_feature(const struct virtio_device *vdev,
  88.                      unsigned int fbit);
  89.  
  90. /**
  91.  * virtio_has_feature - helper to determine if this device has this feature.
  92.  * @vdev: the device
  93.  * @fbit: the feature bit
  94.  */
  95. static inline bool virtio_has_feature(const struct virtio_device *vdev,
  96.                       unsigned int fbit)
  97. {
  98.     /* Did you forget to fix assumptions on max features? */
  99.     if (__builtin_constant_p(fbit))
  100.         BUILD_BUG_ON(fbit >= 32);
  101.  
  102.     virtio_check_driver_offered_feature(vdev, fbit);
  103.     return test_bit(fbit, vdev->features);
  104. }
  105.  
  106. /**
  107.  * virtio_config_val - look for a feature and get a virtio config entry.
  108.  * @vdev: the virtio device
  109.  * @fbit: the feature bit
  110.  * @offset: the type to search for.
  111.  * @val: a pointer to the value to fill in.
  112.  *
  113.  * The return value is -ENOENT if the feature doesn't exist.  Otherwise
  114.  * the config value is copied into whatever is pointed to by v. */
  115. #define virtio_config_val(vdev, fbit, offset, v) \
  116.     virtio_config_buf((vdev), (fbit), (offset), (v), sizeof(*v))
  117.  
  118. static inline int virtio_config_buf(struct virtio_device *vdev,
  119.                     unsigned int fbit,
  120.                     unsigned int offset,
  121.                     void *buf, unsigned len)
  122. {
  123.     if (!virtio_has_feature(vdev, fbit))
  124.         return -ENOENT;
  125.  
  126.     vdev->config->get(vdev, offset, buf, len);
  127.     return 0;
  128. }
  129. #endif /* __KERNEL__ */
  130. #endif /* _LINUX_VIRTIO_CONFIG_H */
  131.